\chapter{Montagem de Máquinas Virtuais}
\label{Montar_vm}

O ambiente de testes foi montado fazendo uso de máquinas virtuais. A \ac{UML} é nativa no
\textit{linux} e apresenta alto desempenho.

O uso das máquinas virtuais UML é muito fácil, simplesmente é necessário um
\textit{kernel} compilado para este tipo especifico de arquitetura e um
\textit{filesystem}. Neste
trabalho, utilizamos tanto o \textit{host} como a máquina virtual baseado na distribuição
Debian.

\subsubsection{Criando o Kernel}
\label{Montar_vm_kernel}

Para montar a máquina virtual é preciso um kernel compilado para a arquitetura
UML. Para este ambiente foi utilizado a versão 2.6.25.6 do \textit{kernel}. A
criação de
um kernel \textit{linux} para uml é um procedimento relativamente simples,
conforme
descrito com os passos abaixo:

Obtendo o Kernel:

\begin{verbatim}
$ wget http://kernel.org/pub/linux/kernel/v2.6/linux-2.6.25.6.tar.bz2
$ tar jxvf linux-2.6.25.6.tar.bz2
$ cd linux-2.6.25.6
\end{verbatim}

Como o ambiente de testes será utilizado máquinas virtuais devemos compilar o
kernel para essa arquitetura:

\verb|$ export ARCH=um|

Configurando kernel:

\verb|$ make defconfig|
\verb|$ make menuconfig|

É interessante habilitar a opção \textit{HOSTFS} para as máquinas virtuais terem
acesso
ao \textit{filesystem} do \textit{host} e as opções que estão em desuso do NETLINK. Para
configurar o kernel com suporte as opções deste trabalho, selecione no kernel as
opções de \textit{FIREWALL} e as tabelas (NAT, MANGLE, FILTER), NET, NETLINK, e
opções de QoS. Estas opções devem ser setadas, no arquivo .config:

Após configurado o kernel deve ser compilado, os seus módulos serão instalados
no diretório \textit{uml-modules} para depois serem copiados para o
\textit{filesystem} da máquina
virtual. O filesystem pode ser obtido no site
\textit{http://uml.nagafix.co.uk/}, que contém também alguns kernels do
linux pré-compilados.

\begin{verbatim}
$ make
$ strip linux
$ make modules_install INSTALL_MOD_PATH=uml-modules
$ unset arch
\end{verbatim}

Como se faz uso de máquinas virtuais é necessário copiar os módulos para o
\textit{filesystem} que será utilizado. Para isso:

\begin{verbatim}
# mkdir loop
# mount -o loop <seu_fs> loop
# cp -rf linux-2.6.25.6/uml-modules/lib/modules/* loop/lib/modules
\end{verbatim}

\subsubsection{Interface comunicação VM/Host}
\label{Montar_vm_Interface_vm-host}
Para criar algumas funções de comunicação que podem ser úteis durante o uso da
máquina virtual, aconselha-se a instalação dos seguintes pacotes:

\verb|#apt-get install uml-utilities openvpn openssl|

Existem dois modos para criar interfaces de rede para a máquina virtual, através
de interface virtual do \textit{host} com o \textit{tunctl} ou através do
\textit{uml\_switch}.

\verb|# tunctl -u \textit{seu_usuario}|

O comando acima cria um interface virtual, por exemplo, tap0. Se invocado
novamente cria a tap1 e sucessivamente. Esta interface permite que a máquina
virtual possa acessar a internet, o que facilita a instalação de pacotes dentro
da mesma.

Configura-se a interface normalmente:

\verb|# ifconfig tap0 192.168.20.1 up|

Para apagar a interface, utilize a opção -d:

\verb|# tunctl -d tap0|

Ativar o roteamento de pacotes na máquina \textit{host}:

\verb|# echo 1 > /proc/sys/net/ipv4/ip_forward|

Há outro meio de criar uma interface de rede para conectar as máquinas virtuais,
que cria um \textit{switch}, utilizando a \textit{uml\_switch}. Este modo foi o
utilizado neste
trabalho para a montagem de cenários, para isto cria-se um switch com o comando:


\verb|$ uml_switch -unix /tmp/net100.ctl|

Onde net100.ctl é o nome do \textit{switch} que será referenciado na
inicialização da UML.

\subsubsection{Utilizando a máquina Virtual}
\label{Montar_vm_utilizar_vm}
Após criado o \textit{Kernel} e o \textit{Filesystem} com os módulos do
\textit{kernel} compilado, pode-se
invocar a máquina virtual, certificando-se de apontar os arquivos conforme
diretório.

Para chamar a máquina virtual, altera-se a interface de comunicação
conforme abaixo:
\begin{verbatim}
$ xterm -title Debian1 -e ./linux ubda=Debian-4.0-x86-root_fs
eth0=daemon,,,/tmp/net100.ctl
\end{verbatim}
Ou para compartilhar através da interface tap0:
\begin{verbatim}
$ xterm -title Debian1 -e ./linux ubd0=Debian-4.0-x86-root_fs
eth0=tuntap,tap0
\end{verbatim}
Ou Ainda...
\begin{verbatim}
$ xterm -title Debian1 -e ./linux-ro
ubd0=./cow-host1,./Debian-4.0-x86-root_fs eth0=tuntap,tap0
\end{verbatim}

Neste último caso, cria-se um \textit{filesystem} de uma máquina
\textit{virtual}, como
\textit{cow-host1}, que poderá ser invocado conforme o primeiro comando. Neste
modo, as
configurações feitas e salvas no \textit{cow-host1} poderão ser utilizadas na
próxima inicialização.

Onde:
\begin{enumerate}
 \item xterm: Programa para abrir a máquina virtual em janela do Ambiente
Gráfico, com os seguintes parâmetros:

\begin{itemize}
 \item -title: Passa o nome para a janela do \textit{xterm}
 \item -e: Passa comando para ser executado dentro da janela do \textit{xterm}.
Aqui
chamaremos a máquina virtual.
\end{itemize}

 \item ./linux: O caminho do \textit{kernel} da Máquina Virtual.
 \item ubd0=: O caminho do \textit{Filesystem} da Máquina Virtual.
 \item eth0=: A interface de rede que a máquina virtual irá comunicar, exemplo:
tuntap,tap0
\end{enumerate}

\subsubsection{Montando o diretório do Host na Máquina Virtual}
\label{Montar_vm_montar_host-vm}
Na máquina host, cria-se uma pasta com o comando:

\verb|# mkdir host|

Com a máquina virtual funcionado, trabalhe como um sistema operacional igual.

Monte o diretório do \textit{host} na máquina virtual:

\verb|# mount none /host(pasta VM) -t hostfs -o /home/rodrigo(pasta host)|

Você também pode montar a unidade de mídia removível, conforme segue:

\verb|# mount none /cdrom -t hostfs -o /cdrom/|

Acese o diretório correspondente ao \textit{cdrom}.

\verb|# mount none /cdrom/ -t hostfs udf,iso9660 -o /cdrom/|